package cn.actoncode.boot.framework.common.util.validation;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.Assert;
import org.springframework.util.NumberUtils;
import org.springframework.util.StringUtils;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 *
 *
 * @author bin
 * @date 2019/12/17 15:38
 */
public class Validator extends Assert {

    private static final String CONTAIN_ZH_CN = "[\u4e00-\u9fa5]";
    private static final String FULL_ZH_CN = ".*[\u4e00-\u9fff]+.*";

    /***
     * log日志
     */
    private static final Logger logger = LoggerFactory.getLogger(Validator.class);

    public static void hasText(String text, String message) {
        if (!StringUtils.hasText(text)) {
            throw new IllegalArgumentException(message);
        }
    }

    /***
     * 大于
     *
     * @param value   待比较的值
     * @param goal    被比较的值
     * @param message 异常信息输出
     */
    public static void gt(int value, int goal, String message) {
        if (value <= goal) {
            throw new IllegalArgumentException(message);
        }
    }


    /***
     * 小于
     *
     * @param value   待比较的值
     * @param goal    被比较的值
     * @param message 异常信息输出
     */
    public static void lt(int value, int goal, String message) {
        if (value >= goal) {
            throw new IllegalArgumentException(message);
        }
    }

    /***
     * 大于
     *
     * @param value   待比较的值
     * @param goal    被比较的值
     * @param message 异常信息输出
     */
    public static void gt(long value, long goal, String message) {
        if (value < goal) {
            throw new IllegalArgumentException(message);
        }
    }

    /***
     * 在数值区间内(startR-区间起点,endR-区间终点)
     *
     * @param value   待校验值
     * @param startR  起点
     * @param endR    结束点
     * @param message 异常信息
     */
    public static void inRange(int value, int startR, int endR, String message) {
        if (value < startR || value > endR) {
            throw new IllegalArgumentException(message);
        }
    }

    /***
     * 在数值区间内(startR-区间起点,endR-区间终点)
     *
     * @param value   待校验值
     * @param startR  起点
     * @param endR    结束点
     * @param message 异常信息
     */
    public static void inRange(long value, long startR, long endR, String message) {
        if (value < startR || value > endR) {
            throw new IllegalArgumentException(message);
        }
    }

    /***
     * 在数值区间内(startR-区间起点,endR-区间终点)
     *
     * @param value   待校验值
     * @param startR  起点
     * @param endR    结束点
     * @param message 异常信息
     */
    public static void inRange(float value, float startR, float endR, String message) {
        if (value < startR || value > endR) {
            throw new IllegalArgumentException(message);
        }
    }

    /***
     * 在数值区间内(startR-区间起点,endR-区间终点)
     *
     * @param value   待校验值
     * @param startR  起点
     * @param endR    结束点
     * @param message 异常信息
     */
    public static void inRange(double value, double startR, double endR, String message) {
        if (value < startR || value > endR) {
            throw new IllegalArgumentException(message);
        }
    }


    /****
     * 至少一项非空
     *
     * @param values  待校验数组
     * @param message 异常信息输出
     */
    public static void atLeastOneText(String[] values, String message) {
        if (null == values || values.length == 0) {
            throw new IllegalArgumentException(message);
        }
        for (String value : values) {
            if (StringUtils.hasText(value)) {
                return;
            }
        }
        throw new IllegalArgumentException(message);
    }

    /****
     * 验证是否是手机
     *
     * @param mobiles 手机
     * @param message 异常信息输出
     */
    public static void isMobileNO(String mobiles, String message) {
        if (!isMobileNo(mobiles)) {
            throw new IllegalArgumentException(message);
        }
    }

    /****
     * 验证是否是手机
     *
     * @param mobile 手机
     * @return true/false
     */
    public static boolean isMobileNo(String mobile) {
//        String regex = "^((13[0-9])|(14[0-9])|(15[0-9])|(18[0-9])|(17[0-9])|(19[0-9]))\\d{8}$";
        String regex = "^1[3-9]\\d{9}$";
        return mobile.matches(regex);
    }

    /****
     * 验证是否为MD5格式
     *
     * @param md5Code md5编号
     * @param message 异常信息输出
     */
    public static void isMD5Code(String md5Code, String message) {
        String regex = "[0-9a-z]{32}$";
        if (!md5Code.matches(regex)) {
            throw new IllegalArgumentException(message);
        }
    }


    /***
     * 验证是否为name格式
     *
     * @param name    name
     * @param message 异常信息输出
     */
    public static void isName(String name, String message) {
        String regex = "^[a-zA-Z0-9]{4,20}";
        if (!name.matches(regex)) {
            throw new IllegalArgumentException(message);
        }
    }

    /***
     * 是否指定格式的日期字符串
     *
     * @param date    日期
     * @param regex   正则
     * @param message 异常信息输出
     */
    public static void isDateFormat(String date, String regex, String message) {
        hasText(date, message);
        if (!date.matches(regex)) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 是否是正的int类型
     *
     * @param inte    待校验
     * @param message 异常信息
     */
    public static int isPlusInt(String inte, String message) {
        String regex = "^([+]?)([0-9]+)$";
        if (!inte.matches(regex)) {
            throw new IllegalArgumentException(message);
        }
        return NumberUtils.parseNumber(inte, Integer.class);
    }

    /**
     * 是否是int类型
     *
     * @param inte    待校验
     * @param message 异常信息
     */
    public static int isInt(String inte, String message) {
        String regex = "^([+-]?)([0-9]+)$";
        if (!inte.matches(regex)) {
            throw new IllegalArgumentException(message);
        }
        return NumberUtils.parseNumber(inte, Integer.class);
    }

    /**
     * 是否是long类型
     *
     * @param longe   待校验
     * @param message 异常信息
     */
    public static long isLong(String longe, String message) {
        String regex = "^([+-]?)([0-9]+)$";
        if (!longe.matches(regex)) {
            throw new IllegalArgumentException(message);
        }
        return NumberUtils.parseNumber(longe, Long.class);
    }


    /***
     * 是否是float类型
     *
     * @param flt     待校验
     * @param message 异常输出
     * @return float
     */
    public static float isFloat(String flt, String message) {
        String regex = "^([+-]?)\\d*(\\.\\d{1,8})?$";
        if (!flt.matches(regex)) {
            throw new IllegalArgumentException(message);
        }
        return NumberUtils.parseNumber(flt, Float.class);
    }


    /***
     * 是否包含中文
     *
     * @param str     待校验
     * @param message 异常输出
     */
    public static void isContainsChinese(String str, String message) {
        Matcher matcher = Pattern.compile(CONTAIN_ZH_CN).matcher(str);
        if (matcher.find()) {
            throw new IllegalArgumentException(message);
        }
    }

    /***
     * 是否全是中文
     *
     * @param str     待校验
     * @param message 异常输出
     */
    public static void isChinese(String str, String message) {
        Matcher matcher = Pattern.compile(FULL_ZH_CN).matcher(str);
        if (!matcher.matches()) {
            throw new IllegalArgumentException(message);
        }
    }

    /***
     * 有
     *
     * @param minSize 最小值
     * @param maxSize 最大值
     * @param text    待测试值
     * @param message 异常输出
     */
    public static void isRightLength(int minSize, int maxSize, String text, String message) {

        if (text.length() > maxSize || text.length() < minSize) {
            throw new IllegalArgumentException(message);
        }

    }

    /**
     * 是否是空
     *
     * @param oo 对象
     * @return
     */
    public static boolean isNotNull(Object oo) {
        Boolean bol = false;
        if (oo instanceof String) {
            bol = null != oo && !"".equals(oo);
        } else {
            bol = null != oo;
        }
        return bol;
    }

}
